---
title: 面向服务器开发者
description: 开始构建您自己的服务器，以在 Claude for Desktop 和其他客户端中使用
---

在本教程中，我们将构建一个简单的 MCP 天气服务器，并将其连接到主机 Claude for Desktop。我们将从基本设置开始，然后逐步处理更复杂的用例。

### 我们将要构建的内容

许多大型语言模型（LLM）目前无法获取天气预报和严重天气警报。让我们使用 MCP 来解决这个问题！

我们将构建一个暴露两个工具的服务器：`get-alerts` 和 `get-forecast`。然后，我们将把该服务器连接到一个 MCP 主机（在本例中为 Claude for Desktop）：

<Frame>
  <img src="/images/weather-alerts.png" />
</Frame>
<Frame>
  <img src="/images/current-weather.png" />
</Frame>

<Note>
服务器可以连接到任何客户端。我们在此选择 Claude for Desktop 是为了简单起见，但我们也有关于[构建您自己的客户端](/quickstart/client)以及[其他客户端列表](/clients)的指南。
</Note>

<Accordion title="为什么选择 Claude for Desktop 而不是 Claude.ai？">
由于服务器是本地运行的，MCP 目前仅支持桌面主机。远程主机的开发正在积极进行中。
</Accordion>

### 核心 MCP 概念

MCP 服务器可以提供三种主要能力：

1. **资源**：客户端可以读取的类似文件的数据（如 API 响应或文件内容）
2. **工具**：LLM 可以调用的函数（需用户批准）
3. **提示**：帮助用户完成特定任务的预写模板

本教程将主要聚焦于工具。

<Tabs>
<Tab title='Python'>

让我们开始构建我们的天气服务器！[您可以在此处找到我们将要构建的完整代码。](https://github.com/modelcontextprotocol/quickstart-resources/tree/main/weather-server-python)

### 前置知识

本快速入门假设您熟悉：
- Python
- 像 Claude 这样的大型语言模型

### 系统要求

- 已安装 Python 3.10 或更高版本。
- 必须使用 Python MCP SDK 1.2.0 或更高版本。

### 设置您的环境

首先，让我们安装 `uv` 并设置我们的 Python 项目和环境：

<CodeGroup>

```bash MacOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
```

```powershell Windows
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

</CodeGroup>

安装完成后，请重启终端以确保 `uv` 命令被正确识别。

现在，让我们创建并设置我们的项目：

<CodeGroup>
```bash MacOS/Linux
# 创建项目目录
uv init weather
cd weather

# 创建虚拟环境并激活
uv venv
source .venv/bin/activate

# 安装依赖
uv add "mcp[cli]" httpx

# 创建服务器文件
touch weather.py
```

```powershell Windows
# 创建项目目录
uv init weather
cd weather

# 创建虚拟环境并激活
uv venv
.venv\Scripts\activate

# 安装依赖
uv add mcp[cli] httpx

# 创建服务器文件
new-item weather.py
```
</CodeGroup>

现在让我们开始构建您的服务器。

## 构建您的服务器

### 导入包并设置实例

在您的 `weather.py` 文件顶部添加以下内容：
```python
from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP

# 初始化 FastMCP 服务器
mcp = FastMCP("weather")

# 常量
NWS_API_BASE = "https://api.weather.gov"
USER_AGENT = "weather-app/1.0"
```

FastMCP 类使用 Python 类型提示和文档字符串自动生成工具定义，使创建和维护 MCP 工具变得简单。

### 辅助函数

接下来，添加用于查询和格式化美国国家气象服务 API 数据的辅助函数：

```python
async def make_nws_request(url: str) -> dict[str, Any] | None:
    """向 NWS API 发送请求并进行适当的错误处理。"""
    headers = {
        "User-Agent": USER_AGENT,
        "Accept": "application/geo+json"
    }
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=headers, timeout=30.0)
            response.raise_for_status()
            return response.json()
        except Exception:
            return None

def format_alert(feature: dict) -> str:
    """将警报特征格式化为可读字符串。"""
    props = feature["properties"]
    return f"""
事件: {props.get('event', '未知')}
区域: {props.get('areaDesc', '未知')}
严重性: {props.get('severity', '未知')}
描述: {props.get('description', '无描述可用')}
指示: {props.get('instruction', '无具体指示提供')}
"""
```

### 实现工具执行

工具执行处理程序负责实际执行每个工具的逻辑。让我们添加它：

```python
@mcp.tool()
async def get_alerts(state: str) -> str:
    """获取美国某个州的天气警报。

    参数：
        state: 两位美国州代码（例如 CA, NY）
    """
    url = f"{NWS_API_BASE}/alerts/active/area/{state}"
    data = await make_nws_request(url)

    if not data or "features" not in data:
        return "无法获取警报或未找到警报。"

    if not data["features"]:
        return "此州没有活跃警报。"

    alerts = [format_alert(feature) for feature in data["features"]]
    return "\n---\n".join(alerts)

@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
    """获取某个位置的天气预报。

    参数：
        latitude: 位置的纬度
        longitude: 位置的经度
    """
    # 首先获取预报网格端点
    points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
    points_data = await make_nws_request(points_url)

    if not points_data:
        return "无法为此位置获取预报数据。"

    # 从点响应中获取预报 URL
    forecast_url = points_data["properties"]["forecast"]
    forecast_data = await make_nws_request(forecast_url)

    if not forecast_data:
        return "无法获取详细预报。"

    # 将周期格式化为可读的预报
    periods = forecast_data["properties"]["periods"]
    forecasts = []
    for period in periods[:5]:  # 仅显示接下来的 5 个周期
        forecast = f"""
{period['name']}：
温度: {period['temperature']}°{period['temperatureUnit']}
风速: {period['windSpeed']} {period['windDirection']}
预报: {period['detailedForecast']}
"""
        forecasts.append(forecast)

    return "\n---\n".join(forecasts)
```

### 运行服务器

最后，初始化并运行服务器：

```python
if __name__ == "__main__":
    # 初始化并运行服务器
    mcp.run(transport='stdio')
```

您的服务器已完成！运行 `uv run weather.py` 以确认一切正常。

现在让我们使用现有的 MCP 主机 Claude for Desktop 测试您的服务器。

## 使用 Claude for Desktop 测试您的服务器

<Note>
Claude for Desktop 尚未在 Linux 上提供。Linux 用户可以继续学习[构建客户端](/quickstart/client)教程，以构建连接到我们刚刚创建的服务器的 MCP 客户端。
</Note>

首先，确保已安装 Claude for Desktop。[您可以在此处安装最新版本。](https://claude.ai/download) 如果您已经安装了 Claude for Desktop，**请确保已更新到最新版本。**

我们需要为想要使用的 MCP 服务器配置 Claude for Desktop。为此，请使用文本编辑器打开 Claude for Desktop 应用程序配置，位于 `~/Library/Application Support/Claude/claude_desktop_config.json`。如果文件不存在，请确保创建它。

例如，如果您安装了 [VS Code](https://code.visualstudio.com/)：

<Tabs>
<Tab title="MacOS/Linux">
```bash
code ~/Library/Application\ Support/Claude/claude_desktop_config.json
```
</Tab>
<Tab title="Windows">
```powershell
code $env:AppData\Claude\claude_desktop_config.json
```
</Tab>
</Tabs>

然后，您需要在 `mcpServers` 键中添加您的服务器。如果至少有一个服务器正确配置，Claude for Desktop 中才会显示 MCP UI 元素。

在本例中，我们将添加我们的单个天气服务器，如下所示：

<Tabs>
<Tab title="MacOS/Linux">
```json Python
{
    "mcpServers": {
        "weather": {
            "command": "uv",
            "args": [
                "--directory",
                "/ABSOLUTE/PATH/TO/PARENT/FOLDER/weather",
                "run",
                "weather.py"
            ]
        }
    }
}
```
</Tab>
<Tab title="Windows">
```json Python
{
    "mcpServers": {
        "weather": {
            "command": "uv",
            "args": [
                "--directory",
                "C:\\ABSOLUTE\\PATH\\TO\\PARENT\\FOLDER\\weather",
                "run",
                "weather.py"
            ]
        }
    }
}
```
</Tab>
</Tabs>

<Warning>
您可能需要在 `command` 字段中放入 `uv` 可执行文件的完整路径。您可以通过在 MacOS/Linux 上运行 `which uv` 或在 Windows 上运行 `where uv` 来获取此路径。
</Warning>

<Note>
确保传入服务器的绝对路径。
</Note>

这告诉 Claude for Desktop：
1. 有一个名为 "weather" 的 MCP 服务器
2. 通过运行 `uv --directory /ABSOLUTE/PATH/TO/PARENT/FOLDER/weather run weather.py` 启动它

保存文件，并**重启 Claude for Desktop**。
</Tab>

<Tab title='Node'>

让我们开始构建我们的天气服务器！[您可以在此处找到我们将要构建的完整代码。](https://github.com/modelcontextprotocol/quickstart-resources/tree/main/weather-server-typescript)

### 前置知识

本快速入门假设您熟悉：
- TypeScript
- 像 Claude 这样的大型语言模型

### 系统要求

对于 TypeScript，请确保已安装最新版本的 Node。

### 设置您的环境

首先，如果您尚未安装 Node.js 和 npm，请先安装。您可以从 [nodejs.org](https://nodejs.org/) 下载。
验证您的 Node.js 安装：
```bash
node --version
npm --version
```
在本教程中，您需要 Node.js 16 或更高版本。

现在，让我们创建并设置我们的项目：

<CodeGroup>
```bash MacOS/Linux
# 创建项目目录
mkdir weather
cd weather

# 初始化新的 npm 项目
npm init -y

# 安装依赖
npm install @modelcontextprotocol/sdk zod
npm install -D @types/node typescript

# 创建文件
mkdir src
touch src/index.ts
```

```powershell Windows
# 创建项目目录
md weather
cd weather

# 初始化新的 npm 项目
npm init -y

# 安装依赖
npm install @modelcontextprotocol/sdk zod
npm install -D @types/node typescript

# 创建文件
md src
new-item src\index.ts
```
</CodeGroup>

更新您的 package.json，添加 type: "module" 和构建脚本：

```json package.json
{
  "type": "module",
  "bin": {
    "weather": "./build/index.js"
  },
  "scripts": {
    "build": "tsc && chmod 755 build/index.js"
  },
  "files": [
    "build"
  ],
}
```

在项目根目录创建 `tsconfig.json`：

```json tsconfig.json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./build",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}
```

现在让我们开始构建您的服务器。

## 构建您的服务器

### 导入包并设置实例

在您的 `src/index.ts` 文件顶部添加以下内容：
```typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const NWS_API_BASE = "https://api.weather.gov";
const USER_AGENT = "weather-app/1.0";

// 创建服务器实例
const server = new McpServer({
  name: "weather",
  version: "1.0.0",
  capabilities: {
    resources: {},
    tools: {},
  },
});
```

### 辅助函数

接下来，添加用于查询和格式化美国国家气象服务 API 数据的辅助函数：

```typescript
// 用于发送 NWS API 请求的辅助函数
async function makeNWSRequest<T>(url: string): Promise<T | null> {
  const headers = {
    "User-Agent": USER_AGENT,
    Accept: "application/geo+json",
  };

  try {
    const response = await fetch(url, { headers });
    if (!response.ok) {
      throw new Error(`HTTP 错误！状态：${response.status}`);
    }
    return (await response.json()) as T;
  } catch (error) {
    console.error("发送 NWS 请求错误：", error);
    return null;
  }
}

interface AlertFeature {
  properties: {
    event?: string;
    areaDesc?: string;
    severity?: string;
    status?: string;
    headline?: string;
  };
}

// 格式化警报数据
function formatAlert(feature: AlertFeature): string {
  const props = feature.properties;
  return [
    `事件：${props.event || "未知"}`,
    `区域：${props.areaDesc || "未知"}`,
    `严重性：${props.severity || "未知"}`,
    `状态：${props.status || "未知"}`,
    `标题：${props.headline || "无标题"}`,
    "---",
  ].join("\n");
}

interface ForecastPeriod {
  name?: string;
  temperature?: number;
  temperatureUnit?: string;
  windSpeed?: string;
  windDirection?: string;
  shortForecast?: string;
}

interface AlertsResponse {
  features: AlertFeature[];
}

interface PointsResponse {
  properties: {
    forecast?: string;
  };
}

interface ForecastResponse {
  properties: {
    periods: ForecastPeriod[];
  };
}
```

### 实现工具执行

工具执行处理程序负责实际执行每个工具的逻辑。让我们添加它：

```typescript
// 注册天气工具
server.tool(
  "get-alerts",
  "获取某个州的天气警报",
  {
    state: z.string().length(2).describe("两位州代码（例如 CA, NY）"),
  },
  async ({ state }) => {
    const stateCode = state.toUpperCase();
    const alertsUrl = `${NWS_API_BASE}/alerts?area=${stateCode}`;
    const alertsData = await makeNWSRequest<AlertsResponse>(alertsUrl);

    if (!alertsData) {
      return {
        content: [
          {
            type: "text",
            text: "无法检索警报数据",
          },
        ],
      };
    }

    const features = alertsData.features || [];
    if (features.length === 0) {
      return {
        content: [
          {
            type: "text",
            text: `没有 ${stateCode} 的活跃警报`,
          },
        ],
      };
    }

    const formattedAlerts = features.map(formatAlert);
    const alertsText = `为 ${stateCode} 的活跃警报：\n\n${formattedAlerts.join("\n")}`;

    return {
      content: [
        {
          type: "text",
          text: alertsText,
        },
      ],
    };
  },
);

server.tool(
  "get-forecast",
  "获取某个位置的天气预报",
  {
    latitude: z.number().min(-90).max(90).describe("位置的纬度"),
    longitude: z.number().min(-180).max(180).describe("位置的经度"),
  },
  async ({ latitude, longitude }) => {
    // 获取网格点数据
    const pointsUrl = `${NWS_API_BASE}/points/${latitude.toFixed(4)},${longitude.toFixed(4)}`;
    const pointsData = await makeNWSRequest<PointsResponse>(pointsUrl);

    if (!pointsData) {
      return {
        content: [
          {
            type: "text",
            text: `无法为坐标 ${latitude}, ${longitude} 检索网格点数据。此位置可能不受 NWS API 支持（仅支持美国位置）。`,
          },
        ],
      };
    }

    const forecastUrl = pointsData.properties?.forecast;
    if (!forecastUrl) {
      return {
        content: [
          {
            type: "text",
            text: "无法从网格点数据中获取预报 URL",
          },
        ],
      };
    }

    // 获取预报数据
    const forecastData = await makeNWSRequest<ForecastResponse>(forecastUrl);
    if (!forecastData) {
      return {
        content: [
          {
            type: "text",
            text: "无法检索预报数据",
          },
        ],
      };
    }

    const periods = forecastData.properties?.periods || [];
    if (periods.length === 0) {
      return {
        content: [
          {
            type: "text",
            text: "没有可用的预报周期",
          },
        ],
      };
    }

    // 格式化预报周期
    const formattedForecast = periods.map((period: ForecastPeriod) =>
      [
        `${period.name || "未知"}：`,
        `温度：${period.temperature || "未知"}°${period.temperatureUnit || "F"}`,
        `风速：${period.windSpeed || "未知"} ${period.windDirection || ""}`,
        `${period.shortForecast || "无预报可用"}`,
        "---",
      ].join("\n"),
    );

    const forecastText = `为 ${latitude}, ${longitude} 的预报：\n\n${formattedForecast.join("\n")}`;

    return {
      content: [
        {
          type: "text",
          text: forecastText,
        },
      ],
    };
  },
);
```

### 运行服务器

最后，实现主函数以运行服务器：

```typescript
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("天气 MCP 服务器在 stdio 上运行");
}

main().catch((error) => {
  console.error("main() 中的致命错误：", error);
  process.exit(1);
});
```

确保运行 `npm run build` 以构建您的服务器！这是让您的服务器连接的重要步骤。

现在让我们使用现有的 MCP 主机 Claude for Desktop 测试您的服务器。

## 使用 Claude for Desktop 测试您的服务器

<Note>
Claude for Desktop 尚未在 Linux 上提供。Linux 用户可以继续学习[构建客户端](/quickstart/client)教程，以构建连接到我们刚刚创建的服务器的 MCP 客户端。
</Note>

首先，确保已安装 Claude for Desktop。[您可以在此处安装最新版本。](https://claude.ai/download) 如果您已经安装了 Claude for Desktop，**请确保已更新到最新版本。**

我们需要为想要使用的 MCP 服务器配置 Claude for Desktop。为此，请使用文本编辑器打开 Claude for Desktop 应用程序配置，位于 `~/Library/Application Support/Claude/claude_desktop_config.json`。如果文件不存在，请确保创建它。

例如，如果您安装了 [VS Code](https://code.visualstudio.com/)：

<Tabs>
<Tab title="MacOS/Linux">
```bash
code ~/Library/Application\ Support/Claude/claude_desktop_config.json
```
</Tab>
<Tab title="Windows">
```powershell
code $env:AppData\Claude\claude_desktop_config.json
```
</Tab>
</Tabs>

然后，您需要在 `mcpServers` 键中添加您的服务器。如果至少有一个服务器正确配置，Claude for Desktop 中才会显示 MCP UI 元素。

在本例中，我们将添加我们的单个天气服务器，如下所示：

<Tabs>
<Tab title="MacOS/Linux">
<CodeGroup>
```json Node
{
    "mcpServers": {
        "weather": {
            "command": "node",
            "args": [
                "/ABSOLUTE/PATH/TO/PARENT/FOLDER/weather/build/index.js"
            ]
        }
    }
}
```
</CodeGroup>
</Tab>
<Tab title="Windows">
<CodeGroup>
```json Node
{
    "mcpServers": {
        "weather": {
            "command": "node",
            "args": [
                "C:\\PATH\\TO\\PARENT\\FOLDER\\weather\\build\\index.js"
            ]
        }
    }
}
```
</CodeGroup>
</Tab>
</Tabs>

这告诉 Claude for Desktop：
1. 有一个名为 "weather" 的 MCP 服务器
2. 通过运行 `node /ABSOLUTE/PATH/TO/PARENT/FOLDER/weather/build/index.js` 启动它

保存文件，并**重启 Claude for Desktop**。
</Tab>

<Tab title='Java'>

<Note>
这是一个基于 Spring AI MCP 自动配置和启动器的快速入门演示。
要了解如何手动创建同步和异步 MCP 服务器，请参阅 [Java SDK 服务器](/sdk/java/mcp-server) 文档。
</Note>

让我们开始构建我们的天气服务器！
[您可以在此处找到我们将要构建的完整代码。](https://github.com/spring-projects/spring-ai-examples/tree/main/model-context-protocol/weather/starter-stdio-server)

有关更多信息，请参阅 [MCP 服务器启动器](https://docs.spring.io/spring-ai/reference/api/mcp/mcp-server-boot-starter-docs.html) 参考文档。
有关手动 MCP 服务器实现的详细信息，请参阅 [MCP 服务器 Java SDK 文档](/sdk/java/mcp-server)。

### 系统要求

- 已安装 Java 17 或更高版本。
- [Spring Boot 3.3.x](https://docs.spring.io/spring-boot/installing.html) 或更高版本

### 设置您的环境

使用 [Spring Initializer](https://start.spring.io/) 初始化项目。

您需要添加以下依赖项：

<Tabs>
  <Tab title="Maven">
  ```xml
  <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-starter-mcp-server</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>
  </dependencies>
  ```
  </Tab>
  <Tab title="Gradle">
  ```groovy
  dependencies {
    implementation platform("org.springframework.ai:spring-ai-starter-mcp-server")
    implementation platform("org.springframework:spring-web")   
  }
  ```
  </Tab>
</Tabs>

然后通过设置应用程序属性来配置您的应用程序：

<CodeGroup>

```bash application.properties
spring.main.bannerMode=off
logging.pattern.console=
```

```yaml application.yml
logging:
  pattern:
    console:
spring:
  main:
    banner-mode: off
```
</CodeGroup>

[服务器配置属性](https://docs.spring.io/spring-ai/reference/api/mcp/mcp-server-boot-starter-docs.html#_configuration_properties) 文档列出了所有可用属性。

现在让我们开始构建您的服务器。

## 构建您的服务器

### 天气服务

让我们实现一个 [WeatherService.java](https://github.com/spring-projects/spring-ai-examples/blob/main/model-context-protocol/weather/starter-stdio-server/src/main/java/org/springframework/ai/mcp/sample/server/WeatherService.java)，它使用 REST 客户端查询美国国家气象服务 API 的数据：

```java
@Service
public class WeatherService {

	private final RestClient restClient;

	public WeatherService() {
		this.restClient = RestClient.builder()
			.baseUrl("https://api.weather.gov")
			.defaultHeader("Accept", "application/geo+json")
			.defaultHeader("User-Agent", "WeatherApiClient/1.0 (your@email.com)")
			.build();
	}

  @Tool(description = "获取特定纬度/经度的天气预报")
  public String getWeatherForecastByLocation(
      double latitude,   // 纬度坐标
      double longitude   // 经度坐标
  ) {
      // 返回详细的预报，包括：
      // - 温度和单位
      // - 风速和方向
      // - 详细的预报描述
  }
	
  @Tool(description = "获取美国某个州的天气警报")
  public String getAlerts(
      @ToolParam(description = "两位美国州代码（例如 CA, NY)") String state
  ) {
      // 返回活跃警报，包括：
      // - 事件类型
      // - 受影响区域
      // - 严重性
      // - 描述
      // - 安全指示
  }

  // ......
}
```

`@Service` 注解会自动将服务注册到您的应用程序上下文中。
Spring AI 的 `@Tool` 注解使创建和维护 MCP 工具变得简单。

自动配置会自动将这些工具注册到 MCP 服务器。

### 创建您的启动应用程序

```java
@SpringBootApplication
public class McpServerApplication {

	public static void main(String[] args) {
		SpringApplication.run(McpServerApplication.class, args);
	}

	@Bean
	public ToolCallbackProvider weatherTools(WeatherService weatherService) {
		return MethodToolCallbackProvider.builder().toolObjects(weatherService).build();
	}
}
```

使用 `MethodToolCallbackProvider` 工具将 `@Tools` 转换为 MCP 服务器使用的可执行回调。

### 运行服务器

最后，构建服务器：

```bash
./mvnw clean install
```

这将在 `target` 文件夹中生成一个 `mcp-weather-stdio-server-0.0.1-SNAPSHOT.jar` 文件。

现在让我们使用现有的 MCP 主机 Claude for Desktop 测试您的服务器。

## 使用 Claude for Desktop 测试您的服务器

<Note>
Claude for Desktop 尚未在 Linux 上提供。
</Note>

首先，确保已安装 Claude for Desktop。
[您可以在此处安装最新版本。](https://claude.ai/download) 如果您已经安装了 Claude for Desktop，**请确保已更新到最新版本。**

我们需要为想要使用的 MCP 服务器配置 Claude for Desktop。
为此，请使用文本编辑器打开 Claude for Desktop 应用程序配置，位于 `~/Library/Application Support/Claude/claude_desktop_config.json`。
如果文件不存在，请确保创建它。

例如，如果您安装了 [VS Code](https://code.visualstudio.com/)：

<Tabs>
  <Tab title="MacOS/Linux">
  ```bash
  code ~/Library/Application\ Support/Claude/claude_desktop_config.json
  ```
  </Tab>
  <Tab title="Windows">
  ```powershell
  code $env:AppData\Claude\claude_desktop_config.json
  ```
  </Tab>
</Tabs>

然后，您需要在 `mcpServers` 键中添加您的服务器。
如果至少有一个服务器正确配置，Claude for Desktop 中才会显示 MCP UI 元素。

在本例中，我们将添加我们的单个天气服务器，如下所示：

<Tabs>
  <Tab title="MacOS/Linux">
  ```json java
  {
    "mcpServers": {
      "spring-ai-mcp-weather": {
        "command": "java",
        "args": [
          "-Dspring.ai.mcp.server.stdio=true",
          "-jar",
          "/ABSOLUTE/PATH/TO/PARENT/FOLDER/mcp-weather-stdio-server-0.0.1-SNAPSHOT.jar"
        ]
      }
    }
  }
  ```
  </Tab>

  <Tab title="Windows">
  ```json java
  {
    "mcpServers": {
      "spring-ai-mcp-weather": {
        "command": "java",
        "args": [
          "-Dspring.ai.mcp.server.transport=STDIO",
          "-jar",
          "C:\\ABSOLUTE\\PATH\\TO\\PARENT\\FOLDER\\weather\\mcp-weather-stdio-server-0.0.1-SNAPSHOT.jar"
        ]
      }
    }
  }
  ```
  </Tab>
</Tabs>

<Note>
确保传入服务器的绝对路径。
</Note>

这告诉 Claude for Desktop：
1. 有一个名为 "spring-ai-mcp-weather" 的 MCP 服务器
2. 通过运行 `java -jar /ABSOLUTE/PATH/TO/PARENT/FOLDER/mcp-weather-stdio-server-0.0.1-SNAPSHOT.jar` 启动它

保存文件，并**重启 Claude for Desktop**。

## 使用 Java 客户端测试您的服务器

### 手动创建 MCP 客户端

使用 `McpClient` 连接到服务器：

```java
var stdioParams = ServerParameters.builder("java")
  .args("-jar", "/ABSOLUTE/PATH/TO/PARENT/FOLDER/mcp-weather-stdio-server-0.0.1-SNAPSHOT.jar")
  .build();

var stdioTransport = new StdioClientTransport(stdioParams);

var mcpClient = McpClient.sync(stdioTransport).build();

mcpClient.initialize();

ListToolsResult toolsList = mcpClient.listTools();

CallToolResult weather = mcpClient.callTool(
  new CallToolRequest("getWeatherForecastByLocation",
      Map.of("latitude", "47.6062", "longitude", "-122.3321")));

CallToolResult alert = mcpClient.callTool(
  new CallToolRequest("getAlerts", Map.of("state", "NY")));

mcpClient.closeGracefully();
```

### 使用 MCP 客户端启动器

使用 `spring-ai-starter-mcp-client` 依赖项创建新的启动器应用程序：

```xml
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-starter-mcp-client</artifactId>
</dependency>
```

并将 `spring.ai.mcp.client.stdio.servers-configuration` 属性设置为指向您的 `claude_desktop_config.json`。
您可以重用现有的 Anthropic Desktop 配置：

```properties
spring.ai.mcp.client.stdio.servers-configuration=file:PATH/TO/claude_desktop_config.json
```

启动客户端应用程序时，自动配置将从 claude_desktop_config.json 中自动创建 MCP 客户端。

有关更多信息，请参阅 [MCP 客户端启动器](https://docs.spring.io/spring-ai/reference/api/mcp/mcp-server-boot-client-docs.html) 参考文档。

## 更多 Java MCP 服务器示例

[starter-webflux-server](https://github.com/spring-projects/spring-ai-examples/tree/main/model-context-protocol/weather/starter-webflux-server) 展示了如何使用 SSE 传输创建 MCP 服务器。
它展示了如何使用 Spring Boot 的自动配置功能定义和注册 MCP 工具、资源和提示。

</Tab>

<Tab title='Kotlin'>

让我们开始构建我们的天气服务器！[您可以在此处找到我们将要构建的完整代码。](https://github.com/modelcontextprotocol/kotlin-sdk/tree/main/samples/weather-stdio-server)

### 前置知识

本快速入门假设您熟悉：
- Kotlin
- 像 Claude 这样的大型语言模型

### 系统要求

- 已安装 Java 17 或更高版本。

### 设置您的环境

首先，如果您尚未安装 `java` 和 `gradle`，请先安装。
您可以从 [官方 Oracle JDK 网站](https://www.oracle.com/java/technologies/downloads/) 下载 `java`。
验证您的 `java` 安装：
```bash
java --version
```

现在，让我们创建并设置您的项目：

<CodeGroup>
```bash MacOS/Linux
# 创建项目目录
mkdir weather
cd weather

# 初始化新的 Kotlin 项目
gradle init
```

```powershell Windows
# 创建项目目录
md weather
cd weather

# 初始化新的 Kotlin 项目
gradle init
```
</CodeGroup>

运行 `gradle init` 后，您将看到创建项目的选项。
选择 **Application** 作为项目类型，**Kotlin** 作为编程语言，**Java 17** 作为 Java 版本。

或者，您可以使用 [IntelliJ IDEA 项目向导](https://kotlinlang.org/docs/jvm-get-started.html) 创建 Kotlin 应用程序。

创建项目后，添加以下依赖项：
<CodeGroup>
```kotlin build.gradle.kts
val mcpVersion = "0.4.0"
val slf4jVersion = "2.0.9"
val ktorVersion = "3.1.1"

dependencies {
    implementation("io.modelcontextprotocol:kotlin-sdk:$mcpVersion")
    implementation("org.slf4j:slf4j-nop:$slf4jVersion")
    implementation("io.ktor:ktor-client-content-negotiation:$ktorVersion")
    implementation("io.ktor:ktor-serialization-kotlinx-json:$ktorVersion")
}
```

```groovy build.gradle
def mcpVersion = '0.3.0'
def slf4jVersion = '2.0.9'
def ktorVersion = '3.1.1'

dependencies {
    implementation "io.modelcontextprotocol:kotlin-sdk:$mcpVersion"
    implementation "org.slf4j:slf4j-nop:$slf4jVersion"
    implementation "io.ktor:ktor-client-content-negotiation:$ktorVersion"
    implementation "io.ktor:ktor-serialization-kotlinx-json:$ktorVersion"
}
```
</CodeGroup>

同时，在构建脚本中添加以下插件：
<CodeGroup>
```kotlin build.gradle.kts
plugins {
    kotlin("plugin.serialization") version "your_version_of_kotlin"
    id("com.github.johnrengelman.shadow") version "8.1.1"
}
```

```groovy build.gradle
plugins {
    id 'org.jetbrains.kotlin.plugin.serialization' version 'your_version_of_kotlin'
    id 'com.github.johnrengelman.shadow' version '8.1.1'
}
```
</CodeGroup>

现在让我们开始构建您的服务器。

## 构建您的服务器

### 设置实例

添加服务器初始化函数：

```kotlin
// 运行 MCP 服务器的主函数
fun `run mcp server`() {
    // 使用基本实现创建 MCP 服务器实例
    val server = Server(
        Implementation(
            name = "weather", // 工具名称为 "weather"
            version = "1.0.0" // 实现版本
        ),
        ServerOptions(
            capabilities = ServerCapabilities(tools = ServerCapabilities.Tools(listChanged = true))
        )
    )

    // 使用标准 I/O 创建传输以进行服务器通信
    val transport = StdioServerTransport(
        System.`in`.asInput(),
        System.out.asSink().buffered()
    )

    runBlocking {
        server.connect(transport)
        val done = Job()
        server.onClose {
            done.complete()
        }
        done.join()
    }
}
```

### 天气 API 辅助函数

接下来，添加用于查询和转换美国国家气象服务 API 响应的函数和数据类：

```kotlin
// 用于获取给定纬度和经度的预报信息的扩展函数
suspend fun HttpClient.getForecast(latitude: Double, longitude: Double): List<String> {
    val points = this.get("/points/$latitude,$longitude").body<Points>()
    val forecast = this.get(points.properties.forecast).body<Forecast>()
    return forecast.properties.periods.map { period ->
        """
            ${period.name}:
            温度: ${period.temperature} ${period.temperatureUnit}
            风速: ${period.windSpeed} ${period.windDirection}
            预报: ${period.detailedForecast}
        """.trimIndent()
    }
}

// 用于获取给定州的天气警报的扩展函数
suspend fun HttpClient.getAlerts(state: String): List<String> {
    val alerts = this.get("/alerts/active/area/$state").body<Alert>()
    return alerts.features.map { feature ->
        """
            事件: ${feature.properties.event}
            区域: ${feature.properties.areaDesc}
            严重性: ${feature.properties.severity}
            描述: ${feature.properties.description}
            指示: ${feature.properties.instruction}
        """.trimIndent()
    }
}

@Serializable
data class Points(
    val properties: Properties
) {
    @Serializable
    data class Properties(val forecast: String)
}

@Serializable
data class Forecast(
    val properties: Properties
) {
    @Serializable
    data class Properties(val periods: List<Period>)

    @Serializable
    data class Period(
        val number: Int, val name: String, val startTime: String, val endTime: String,
        val isDaytime: Boolean, val temperature: Int, val temperatureUnit: String,
        val temperatureTrend: String, val probabilityOfPrecipitation: JsonObject,
        val windSpeed: String, val windDirection: String,
        val shortForecast: String, val detailedForecast: String,
    )
}

@Serializable
data class Alert(
    val features: List<Feature>
) {
    @Serializable
    data class Feature(
        val properties: Properties
    )

    @Serializable
    data class Properties(
        val event: String, val areaDesc: String, val severity: String,
        val description: String, val instruction: String?,
    )
}
```

### 实现工具执行

工具执行处理程序负责实际执行每个工具的逻辑。让我们添加它：

```kotlin
// 创建具有默认请求配置和 JSON 内容协商的 HTTP 客户端
val httpClient = HttpClient {
    defaultRequest {
        url("https://api.weather.gov")
        headers {
            append("Accept", "application/geo+json")
            append("User-Agent", "WeatherApiClient/1.0")
        }
        contentType(ContentType.Application.Json)
    }
    // 为 JSON 序列化/反序列化安装内容协商插件
    install(ContentNegotiation) { json(Json { ignoreUnknownKeys = true }) }
}

// 注册一个按州获取天气警报的工具
server.addTool(
    name = "get_alerts",
    description = """
        获取美国某个州的天气警报。输入为两位美国州代码（例如 CA, NY）
    """.trimIndent(),
    inputSchema = Tool.Input(
        properties = buildJsonObject {
            putJsonObject("state") {
                put("type", "string")
                put("description", "两位美国州代码（例如 CA, NY）")
            }
        },
        required = listOf("state")
    )
) { request ->
    val state = request.arguments["state"]?.jsonPrimitive?.content
    if (state == null) {
        return@addTool CallToolResult(
            content = listOf(TextContent("需要 'state' 参数。"))
        )
    }

    val alerts = httpClient.getAlerts(state)

    CallToolResult(content = alerts.map { TextContent(it) })
}

// 注册一个按纬度和经度获取天气预报的工具
server.addTool(
    name = "get_forecast",
    description = """
        获取特定纬度/经度的天气预报
    """.trimIndent(),
    inputSchema = Tool.Input(
        properties = buildJsonObject {
            putJsonObject("latitude") { put("type", "number") }
            putJsonObject("longitude") { put("type", "number") }
        },
        required = listOf("latitude", "longitude")
    )
) { request ->
    val latitude = request.arguments["latitude"]?.jsonPrimitive?.doubleOrNull
    val longitude = request.arguments["longitude"]?.jsonPrimitive?.doubleOrNull
    if (latitude == null || longitude == null) {
        return@addTool CallToolResult(
            content = listOf(TextContent("需要 'latitude' 和 'longitude' 参数。"))
        )
    }

    val forecast = httpClient.getForecast(latitude, longitude)

    CallToolResult(content = forecast.map { TextContent(it) })
}
```

### 运行服务器

最后，实现主函数以运行服务器：

```kotlin
fun main() = `run mcp server`()
```

确保运行 `./gradlew build` 以构建您的服务器。这是让您的服务器连接的重要步骤。

现在让我们使用现有的 MCP 主机 Claude for Desktop 测试您的服务器。

## 使用 Claude for Desktop 测试您的服务器

<Note>
Claude for Desktop 尚未在 Linux 上提供。Linux 用户可以继续学习[构建客户端](/quickstart/client)教程，以构建连接到我们刚刚创建的服务器的 MCP 客户端。
</Note>

首先，确保已安装 Claude for Desktop。[您可以在此处安装最新版本。](https://claude.ai/download) 如果您已经安装了 Claude for Desktop，**请确保已更新到最新版本。**

我们需要为想要使用的 MCP 服务器配置 Claude for Desktop。
为此，请使用文本编辑器打开 Claude for Desktop 应用程序配置，位于 `~/Library/Application Support/Claude/claude_desktop_config.json`。
如果文件不存在，请确保创建它。

例如，如果您安装了 [VS Code](https://code.visualstudio.com/)：

<CodeGroup>
```bash MacOS/Linux
code ~/Library/Application\ Support/Claude/claude_desktop_config.json
```

```powershell Windows
code $env:AppData\Claude\claude_desktop_config.json
```
</CodeGroup>

然后，您需要在 `mcpServers` 键中添加您的服务器。
如果至少有一个服务器正确配置，Claude for Desktop 中才会显示 MCP UI 元素。

在本例中，我们将添加我们的单个天气服务器，如下所示：

<CodeGroup>
```json MacOS/Linux
{
    "mcpServers": {
        "weather": {
            "command": "java",
            "args": [
                "-jar",
                "/ABSOLUTE/PATH/TO/PARENT/FOLDER/weather/build/libs/weather-0.1.0-all.jar"
            ]
        }
    }
}
```

```json Windows
{
    "mcpServers": {
        "weather": {
            "command": "java",
            "args": [
                "-jar",
                "C:\\PATH\\TO\\PARENT\\FOLDER\\weather\\build\\libs\\weather-0.1.0-all.jar"
            ]
        }
    }
}
```
</CodeGroup>

这告诉 Claude for Desktop：
1. 有一个名为 "weather" 的 MCP 服务器
2. 通过运行 `java -jar /ABSOLUTE/PATH/TO/PARENT/FOLDER/weather/build/libs/weather-0.1.0-all.jar` 启动它

保存文件，并**重启 Claude for Desktop**。

</Tab>

<Tab title='C#'>

让我们开始构建我们的天气服务器！[您可以在此处找到我们将要构建的完整代码。](https://github.com/modelcontextprotocol/csharp-sdk/tree/main/samples/QuickstartWeatherServer)

### 前置知识
本快速入门假设您熟悉：
- C#
- 像 Claude 这样的大型语言模型
- .NET 8 或更高版本

### 系统要求
- 已安装 [.NET 8 SDK](https://dotnet.microsoft.com/download/dotnet/8.0) 或更高版本。

### 设置您的环境
首先，如果您尚未安装 `dotnet`，请先安装。您可以从 [官方 Microsoft .NET 网站](https://dotnet.microsoft.com/download/) 下载 `dotnet`。验证您的 `dotnet` 安装：
```bash
dotnet --version
```
现在，让我们创建并设置您的项目：
<CodeGroup>
```bash MacOS/Linux
# 创建项目目录
mkdir weather
cd weather
# 初始化新的 C# 项目
dotnet new console
```

```powershell Windows
# 创建项目目录
mkdir weather
cd weather
# 初始化新的 C# 项目
dotnet new console
```
</CodeGroup>
运行 `dotnet new console` 后，您将获得一个新的 C# 项目。
您可以在您喜欢的 IDE 中打开项目，例如 [Visual Studio](https://visualstudio.microsoft.com/) 或 [Rider](https://www.jetbrains.com/rider/)。
或者，您可以使用 [Visual Studio 项目向导](https://learn.microsoft.com/en-us/visualstudio/get-started/csharp/tutorial-console?view=vs-2022) 创建 C# 应用程序。
创建项目后，添加 Model Context Protocol SDK 和托管的 NuGet 包：

```bash
# 添加 Model Context Protocol SDK NuGet 包
dotnet add package ModelContextProtocol --prerelease
# 添加 .NET 托管 NuGet 包
dotnet add package Microsoft.Extensions.Hosting
```
现在让我们开始构建您的服务器。

## 构建您的服务器

打开项目中的 `Program.cs` 文件，并将其内容替换为以下代码：

```csharp
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using ModelContextProtocol;
using System.Net.Http.Headers;

var builder = Host.CreateEmptyApplicationBuilder(settings: null);

builder.Services.AddMcpServer()
    .WithStdioServerTransport()
    .WithToolsFromAssembly();

builder.Services.AddSingleton(_ =>
{
    var client = new HttpClient() { BaseAddress = new Uri("https://api.weather.gov") };
    client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("weather-tool", "1.0"));
    return client;
});

var app = builder.Build();

await app.RunAsync();
```
<Note>
创建 `ApplicationHostBuilder` 时，请确保使用 `CreateEmptyApplicationBuilder` 而不是 `CreateDefaultBuilder`。这可确保服务器不会向控制台写入任何额外消息。这仅在使用 STDIO 传输的服务器上需要。
</Note>

此代码设置了一个基本的控制台应用程序，使用 Model Context Protocol SDK 创建一个带标准 I/O 传输的 MCP 服务器。

### 天气 API 辅助函数
接下来，定义一个类，包含用于查询和转换美国国家气象服务 API 响应的工具执行处理程序：

```csharp
using ModelContextProtocol.Server;
using System.ComponentModel;
using System.Net.Http.Json;
using System.Text.Json;

namespace QuickstartWeatherServer.Tools;

[McpServerToolType]
public static class WeatherTools
{
    [McpServerTool, Description("获取美国某个州的天气警报。")]
    public static async Task<string> GetAlerts(
        HttpClient client,
        [Description("要获取警报的美国州代码。")] string state)
    {
        var jsonElement = await client.GetFromJsonAsync<JsonElement>($"/alerts/active/area/{state}");
        var alerts = jsonElement.GetProperty("features").EnumerateArray();

        if (!alerts.Any())
        {
            return "此州没有活跃警报。";
        }

        return string.Join("\n--\n", alerts.Select(alert =>
        {
            JsonElement properties = alert.GetProperty("properties");
            return $"""
                    事件: {properties.GetProperty("event").GetString()}
                    区域: {properties.GetProperty("areaDesc").GetString()}
                    严重性: {properties.GetProperty("severity").GetString()}
                    描述: {properties.GetProperty("description").GetString()}
                    指示: {properties.GetProperty("instruction").GetString()}
                    """;
        }));
    }

    [McpServerTool, Description("获取某个位置的天气预报。")]
    public static async Task<string> GetForecast(
        HttpClient client,
        [Description("位置的纬度。")] double latitude,
        [Description("位置的经度。")] double longitude)
    {
        var jsonElement = await client.GetFromJsonAsync<JsonElement>($"/points/{latitude},{longitude}");
        var periods = jsonElement.GetProperty("properties").GetProperty("periods").EnumerateArray();

        return string.Join("\n---\n", periods.Select(period => $"""
                {period.GetProperty("name").GetString()}
                温度: {period.GetProperty("temperature").GetInt32()}°F
                风速: {period.GetProperty("windSpeed").GetString()} {period.GetProperty("windDirection").GetString()}
                预报: {period.GetProperty("detailedForecast").GetString()}
                """));
    }
}
```

### 运行服务器
最后，使用以下命令运行服务器：

```bash
dotnet run
```
这将启动服务器并在标准输入/输出上监听传入请求。

## 使用 Claude for Desktop 测试您的服务器
<Note>
Claude for Desktop 尚未在 Linux 上提供。Linux 用户可以继续学习[构建客户端](/quickstart/client)教程，以构建连接到我们刚刚创建的服务器的 MCP 客户端。
</Note>

首先，确保已安装 Claude for Desktop。[您可以在此处安装最新版本。](https://claude.ai/download) 如果您已经安装了 Claude for Desktop，**请确保已更新到最新版本。**
我们需要为想要使用的 MCP 服务器配置 Claude for Desktop。为此，请使用文本编辑器打开 Claude for Desktop 应用程序配置，位于 `~/Library/Application Support/Claude/claude_desktop_config.json`。如果文件不存在，请确保创建它。
例如，如果您安装了 [VS Code](https://code.visualstudio.com/)：

<Tabs>
<Tab title="MacOS/Linux">
```bash
code ~/Library/Application\ Support/Claude/claude_desktop_config.json
```
</Tab>
<Tab title="Windows">
```powershell
code $env:AppData\Claude\claude_desktop_config.json
```
</Tab>
</Tabs>

然后，您需要在 `mcpServers` 键中添加您的服务器。如果至少有一个服务器正确配置，Claude for Desktop 中才会显示 MCP UI 元素。
在本例中，我们将添加我们的单个天气服务器，如下所示：

<Tabs>
<Tab title="MacOS/Linux">
```json
{
    "mcpServers": {
        "weather": {
            "command": "dotnet",
            "args": [
                "run",
                "--project",
                "/ABSOLUTE/PATH/TO/PROJECT",
                "--no-build"
            ]
        }
    }
}
```

</Tab>

<Tab title="Windows">
```json
{
    "mcpServers": {
        "weather": {
            "command": "dotnet",
            "args": [
                "run",
                "--project",
                "C:\\ABSOLUTE\\PATH\\TO\\PROJECT",
                "--no-build"
            ]
        }
    }
}
```
</Tab>
</Tabs>

这告诉 Claude for Desktop：
1. 有一个名为 "weather" 的 MCP 服务器
2. 通过运行 `dotnet run /ABSOLUTE/PATH/TO/PROJECT` 启动它
保存文件，并**重启 Claude for Desktop**。

</Tab>
</Tabs>

### 使用命令测试

让我们确保 Claude for Desktop 能够识别我们在 `weather` 服务器中暴露的两个工具。您可以通过寻找锤子 <img src="/images/claude-desktop-mcp-hammer-icon.svg" style={{display: 'inline', margin: 0, height: '1.3em'}} /> 图标来确认：

<Frame>
  <img src="/images/visual-indicator-mcp-tools.png" />
</Frame>

点击锤子图标后，您应该看到列出的两个工具：

<Frame>
  <img src="/images/available-mcp-tools.png" />
</Frame>

如果 Claude for Desktop 未识别您的服务器，请继续阅读[故障排除](#troubleshooting)部分以获取调试提示。

如果锤子图标已出现，您现在可以通过在 Claude for Desktop 中运行以下命令测试您的服务器：

- 萨克拉门托的天气如何？
- 德克萨斯州有哪些活跃的天气警报？

<Frame>
  <img src="/images/current-weather.png" />
</Frame>
<Frame>
  <img src="/images/weather-alerts.png" />
</Frame>

<Note>
由于这是美国国家气象服务，查询仅适用于美国位置。
</Note>

## 幕后发生了什么

当您提出问题时：

1. 客户端将您的问题发送给 Claude
2. Claude 分析可用工具并决定使用哪个（或哪些）
3. 客户端通过 MCP 服务器执行所选工具
4. 结果被发送回 Claude
5. Claude 形成自然语言响应
6. 响应显示给您！

## 故障排除

<AccordionGroup>
<Accordion title="Claude for Desktop 集成问题">
**从 Claude for Desktop 获取日志**

Claude.app 相关的 MCP 日志记录在 `~/Library/Logs/Claude` 中的日志文件中：

- `mcp.log` 包含有关 MCP 连接和连接失败的常规日志。
- 名为 `mcp-server-SERVERNAME.log` 的文件包含来自指定服务器的错误（stderr）日志。

您可以运行以下命令列出最近的日志并跟踪任何新日志：
```bash
# 检查 Claude 的日志是否有错误
tail -n 20 -f ~/Library/Logs/Claude/mcp*.log
```

**Claude 中未显示服务器**

1. 检查 `claude_desktop_config.json` 文件的语法
2. 确保项目路径是绝对路径而非相对路径
3. 完全重启 Claude for Desktop

**工具调用无声失败**

如果 Claude 尝试使用工具但失败：

1. 检查 Claude 的日志是否有错误
2. 验证您的服务器构建并运行无错误
3. 尝试重启 Claude for Desktop

**这些都不起作用。我该怎么办？**

请参阅我们的[调试指南](/docs/tools/debugging)，以获取更好的调试工具和更详细的指导。
</Accordion>
<Accordion title="天气 API 问题">
**错误：无法检索网格点数据**

这通常意味着：
1. 坐标在美国以外
2. NWS API 出现问题
3. 您被速率限制

修复方法：

- 验证您使用的是美国坐标
- 在请求之间添加小延迟
- 检查 NWS API 状态页面

**错误：没有 [STATE] 的活跃警报**

这不是错误——只是表示该州当前没有天气警报。尝试其他州或在恶劣天气期间检查。
</Accordion>

</AccordionGroup>

<Note>
有关更高级的故障排除，请查看我们的[MCP 调试指南](/docs/tools/debugging)
</Note>

## 下一步

<CardGroup cols={2}>
  <Card
    title="构建客户端"
    icon="outlet"
    href="/quickstart/client"
  >
    学习如何构建您自己的 MCP 客户端以连接到您的服务器
  </Card>
  <Card
    title="示例服务器"
    icon="grid"
    href="/examples"
  >
    查看我们的官方 MCP 服务器和实现画廊
  </Card>
  <Card
    title="调试指南"
    icon="bug"
    href="/docs/tools/debugging"
  >
    学习如何有效地调试 MCP 服务器和集成
  </Card>
  <Card
    title="使用 LLM 构建 MCP"
    icon="comments"
    href="/tutorials/building-mcp-with-llms"
  >
    学习如何使用像 Claude 这样的 LLM 加速您的 MCP 开发
  </Card>
</CardGroup>
